﻿#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<array>
#include"func.h"

using namespace std;

namespace ganyu
{
	// 定义一个模板类型的静态数组
	template<class T, size_t N>
	class array
	{
		public :
		T & operator[](size_t index) { return _array[index]; }
		const T& operator[](size_t index)const { return _array[index]; }
		size_t size()const { return _size; }
		bool empty()const { return 0 == _size; }
	private:
		T _array[N];
		size_t _size;
	};

	template<size_t N = 10>
	class stack
	{
		
	private:
		int _a[N];
		size_t top;
	};
}

void test1()
{
	int arr1[10];
	array<int, 10> arr2;
}

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}

	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
//
//template<class T>
//bool Less(T const & left, T const & right)
//{
//	return left < right;
//}
//
//template<>
//bool Less<const Date*>(const Date* const & left, const Date* const& right)
//{
//	return *left < *right;
//}
//
//bool Less(Date* left, Date* right)
//{
//	return *left < *right;
//}


//int main()
//{
//	ganyu::stack<> s1;
//	return 0;
//}

//int main()
//{
//	Date d1(2026, 1, 1);
//	Date d2(2025, 1, 1);
//	const Date* p1 = &d1;
//	const Date* p2 = &d2;
//	cout <<" "<< Less(p1, p2) << endl; // 可以比较，结果错误
//
//	return 0;
//}

//int main()
//{
//	int a = 2, b = 1;
//	cout << Less(a, b) << endl;
//
//	int* pa = &a;
//	int* pb = &b;
//	cout << Less(pa, pb) << endl;
//
//	return 0;
//}

template<class T1, class T2>
class Data
{
public :
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};


template<>
class Data<int, char>
{
public :
	Data() { cout << " Data<int, char>" << endl; }
private:
	int _d1;
	char _d2;
};

template<class T1>
class Data<T1, char>
{
public:
	Data() { cout << " Data<T1, char>" << endl; }
private:
	int _d1;
	char _d2;
};


template<class T1>
class Data<T1, double>
{
public:
	Data() { cout << " Data<T1, double>" << endl; }
private:
	int _d1;
	char _d2;
};

//int main()
//{
//	Data<int, int> d1;
//	Data<int, char> d2;
//	return 0;
//}

//int main()
//{
//	Data<int, char> d1;
//	//Data<char, double> d2;
//	return 0;
//}


//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1&, T2*>
{
public :
	Data() { cout << " Data<T1&, T2*>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

//int main()
//{
//	Data<int&, char*> d1;
//	Data<int&, int*> d2;
//	return 0;
//}

template<class T>
class Less
{
public:
	bool operator()(const T& x, const T& y) const  
	{
		return x < y;
	}
};

template<class T>
class Less<T*>
{
public:
	bool operator()( T* const& x,  T* const& y) const
	{
		return *x < *y;
	}
};

//template<class T>
//class Less
//{
//public:
//	bool operator()(const T& x, const T& y)
//	{
//		return x < y;
//	}
//};
//
//template<class T>
//class Less<T*>
//{
//public:
//	bool operator()(T* const& x, T* const& y)
//	{
//		return *x < *y;
//	}
//};


//int main()
//{
//	int a = 1;
//	int b = 0;
//	int* pa = &a;
//	int* pb = &b;
//	double c = 1.0;
//	double d = 2.0;
//
//	cout << Less<int>()(a, b) << endl;
//	cout << Less<int*>()(pa, pb) << endl;
//	cout << Less<double*>()(&c, &d) << endl;
//
//	return 0;



//#include<iostream>
//using namespace std;
//
//template<class T>
//T Add(const T& left, const T& right);
//
//void fun(const int& left, const int& right);
//
//
//int main()
//{
//	Add(1, 2);
//	fun(3, 4);
//
//	return 0;
//}

﻿template<class Type>
Type Max(const Type& a, const Type& b)

{

	cout << "This is Max<Type>" << endl;

	return a > b ? a : b;

}

template<>
int Max<int>(const int& a, const int& b)
{

	cout << "This is Max<int>" << endl;

	return a > b ? a : b;

}

template<>
char Max<char>(const char& a, const char& b)

{

	cout << "This is Max<char>" << endl;

	return a > b ? a : b;

}

int Max(const int& a, const int& b)
{

	cout << "This is Max" << endl;

	return a > b ? a : b;

}

int main()

{

	Max(10, 20);

	Max(12.34, 23.45);

	Max('A', 'B');

	Max<int>(20, 30);

	return 0;

}

